\chapter{Conception et réalisation}
\section{Vers une approche MVC}
Le développement du projet à été axé sur un pattern design particulier le \textit{MVC}. Pour cela tout au long du projet nous nous sommes efforcés de trié les objets et les méthodes qui leurs sont conférés. Ainsi nous observont 3 types d'objet (cf. Figure~\ref{Controller} page~\pageref{Controller}):
\begin{enumerate}
\item Modèle:		ils sont de simple définition d'objet avec des méthodes permettant de les manipuler
\item Vue:			ils sont utilisées pour faire l'interface entre l'utilisateur et le moteur du jeu 
\item Contrôleur:	ils récupèrent les données provenant des objet modèle contrôle leur validité et les transmets a un objet de type vue
\end{enumerate}
\begin{figure}[p]
	\center
	\includegraphics[width=15cm]{img/com.engine.controller.Controller.eps}
	\caption{com.engine.controller.Controller}
	\label{Controller}
\end{figure}
Notre programme JMeta utilise pour le moment une vue de type terminal, on peut greffer par la suite d'autre vue notamment GUI sans imposer de grand remaniement de code, au contraire. De plus on peu coupler à la vue terminal des sous vue, ici qu'une seule à été développé:
\begin{itemize}
	\item DisplayColored pour des affichages dans le terminal coloré (pour les terminaux supportant cette méthode)
\end{itemize}
En effet on pourrait très bien coupler une vue n'utilisant pas des couleurs.
L'avantage d'avoir essayé de se rapprocher du design pattern, confère au programme une très grande modularité et permet au développement avenir des ajouts de code important sans implication du travail précédemment réalisée.
De plus dans le cas ou nous utilisons une vue de type terminal coloré, l'approche mise en place permet de garantir 2 choses:
\begin{enumerate}
\item La taille du terminal, en effet elle est dimansionné dès son ouverture pour une convivialité optimale pour les joueurs
\item La couleur du terminal, en effet vue l'importance de la couleur lors de l'utilisation de ce type de vue il est primordiale de garantir que les couleurs ressorte correctement sur le terminal
\end{enumerate}
\begin{framed}
	\begin{lstlisting}
.........
public final class Terminal
{
	private String	backgroundColor	= "black";
	private String	foregroundColor	= "green";
	private Integer	height	= 100;
	private Integer	width	= 70;
	private ProcessLauncher	xterm	= new ProcessLauncher();
.........
	public Terminal(String backgroundColor, String foregroundColor,
			Integer height, Integer width)
	{
.........
	}
	public void start()
	{
		try
		{
xterm.execute("xterm -bg " + backgroundColor + " -fg "+ foregroundColor + " -geometry " + height + "x" + width+ " -e java com/engine/controller.Controller");
		}
.........
	}
.........
}
	\end{lstlisting}	
\end{framed}
\section{Une class particulière ProcessLauncher}
ProcessLauncher est une classe regroupant les moyens fréquemment utilisées pour lancé des applications externes, mais elle le fait bien. En effet en java la gestion des flux peut être rapidement complexe, ici ProcessLauncher permet d'éxécuter dans deux thread séparé: l'entrée standard et la sortie stantard du programme externe. Ceci permet d'éviter le dead lock.
\section{Initialisation}
Au début du jeu, vous est demandé le nombre de joueurs (humain et/ou ordinateur), les joueurs pourront appartenir à des équipes de leur choix. Le plateau de jeu est implémenté sous forme d'une matrice à 2 dimensions. Une partie de JMeta peut être initialisée de 2 façons : les joueurs peuvent décider de laisser la machine placer les pions aléatoirement pour avoir un gain de temps et commencer une partie immédiatement sinon ils peuvent placer une à une leurs pièces pour ainsi avoir une meilleure stratégie de jeu. La pose aléatoire des pions peut se faire grâce au code suivant (cf. Figure~\ref{InitGrid} page~\pageref{InitGrid}):

\begin{framed}
	\begin{lstlisting}
Integer x = (int) (Math.random() * (higher-lower) + lower);
Integer y = (int) (Math.random() * (higher-lower) + lower);
	\end{lstlisting}	
\end{framed}
			
On arrive à générer des coordonnées aléatoires, il suffit de vérifier si la case obtenue est vide ou non pour poser le pion.

\begin{figure}[p]
	\center
	\includegraphics[width=15cm]{img/com.engine.controller.Controller.initialiseGrid.eps}
	\caption{Méthode com.engine.controller.Controller.initialiseGrid()}
	\label{InitGrid}
\end{figure}

\section{Fonctions du jeu}

Une fois tous les pions posés, la partie peut réellement commencer avec le joueur 1 qui prend la main. Tour à tour, chaque joueur aura 2 pions à bouger (un Métabolite + un Phospholipide ou une Protéine).
Les caractéristiques de déplacement de chaque pion sont contenues dans leurs attributs boolean upLeft, up, upRight, right, downRight, down, downLeft, left. En effet, si un attribut est égal à \textbf{true}, la structure de contrôle saura que le pion peut avancer dans la case associée.
\begin{figure}[p]
	\center
	\includegraphics[width=15cm]{img/com.engine.controller.Controller.calculPossibleCells.eps}
	\caption{Méthode com.engine.controller.Controller.calculPossibleCells()}
\end{figure}
Pour déplacer un pion, le joueur sera sollicité afin de choisir la case contenant le pion qu'il souhaite bouger, puis la case ou il souhaite la voir atterrir au final. 
Pour vérifier si le déplacement est possible, les attributs du pion serviront pour renvoyer un ArrayList de tableaux à 2 éléments qui contiendront les coordonnées. Il y aura donc un test d'égalité entre les coordonnées des cases ou le déplacement est possible et les coordonnées que le joueur a sélectionné.
Dans le cas ou, une Protéine aurait réussi a capturé un Métabolite, une simple incrémentation de l'attribut \textit{score} du joueur est faite. Cet attribut est utilisé pour tester si il y a arrêt de jeu ou non (sachant que la partie se termine lorsqu'un des joueurs a atteint 15 points).

